// store/cart.js
import { defineStore } from "pinia"
import { useUserStore } from "./user"
import http from "@/utils/http/http.js"
//import uni from "uni-app" // Declare the uni variable

// #ifdef H5 || APP-PLUS || MP-WEIXIN || MP-ALIPAY || MP-BAIDU || MP-QQ || MP-TOUTIAO || MP-LARK
// const uni = typeof uni !== 'undefined' ? uni : {};
// #endif

export const useCartStore = defineStore("cart", {
  state: () => ({
    cartItems: [],
    loading: false,
    cartCount: 0,
  }),

  getters: {
    // 计算是否全选
    isAllSelected: (state) => {
      if (state.cartItems.length === 0) return false
      return state.cartItems.every((item) => !!item.selected) // 使用布尔转换
    },

    // 计算选中商品数量
    selectedItemCount: (state) => {
      return state.cartItems.filter((item) => !!item.selected).length
    },

    // 计算选中商品总价
    selectedTotalPrice: (state) => {
      return state.cartItems
        .filter((item) => !!item.selected)
        .reduce((total, item) => total + Number.parseFloat(item.price) * item.quantity, 0)
        .toFixed(2)
    },
  },

  actions: {
    // 获取购物车列表
    async fetchCartList() {
      const userStore = useUserStore()

      // 如果用户未登录，则清空购物车
      if (!userStore.isLoggedIn) {
        this.cartItems = []
        return
      }

      this.loading = true

      try {
        // 这里将来可以替换为后端API调用
        const response = await http.get("/api/cart/list")
        if (response.code === 200 && response.data) {
          // 标准化数据格式，确保 selected 字段为数字类型
          const normalizedData = response.data.map((item) => ({
            ...item,
            selected: item.selected ? 1 : 0, // 统一转换为数字类型
          }))
          // 确保响应式更新
          this.cartItems = [...normalizedData]
        }
      } catch (error) {
        console.error("获取购物车列表失败:", error)
        uni.showToast({
          title: "获取购物车失败，请重试",
          icon: "none",
        })
      } finally {
        this.loading = false
      }
    },

    // 添加商品到购物车
    async addToCart(product, quantity = 1) {
      const userStore = useUserStore()

      // 检查用户是否登录
      if (!userStore.isLoggedIn) {
        uni.showToast({
          title: "请先登录",
          icon: "none",
        })
        return false
      }

      // 检查商品状态和库存
      if (product.status === 0) {
        uni.showToast({
          title: "该商品已下架",
          icon: "none",
        })
        return false
      }

      if (product.totalStock <= 0) {
        uni.showToast({
          title: "该商品库存不足",
          icon: "none",
        })
        return false
      }

      try {
        // 查找购物车中是否已存在该商品
        const existingItemIndex = this.cartItems.findIndex((item) => item.productId === product.id)

        if (existingItemIndex !== -1) {
          // 如果已存在，则增加数量
          const newCartItems = [...this.cartItems]
          newCartItems[existingItemIndex] = {
            ...newCartItems[existingItemIndex],
            quantity: newCartItems[existingItemIndex].quantity + quantity,
          }

          // 检查是否超过库存
          if (newCartItems[existingItemIndex].quantity > product.totalStock) {
            newCartItems[existingItemIndex].quantity = product.totalStock
            uni.showToast({
              title: "已达到最大库存",
              icon: "none",
            })
          }

          this.cartItems = newCartItems
        } else {
          // 如果不存在，则添加新商品
          const cartItem = {
            userId: userStore.userInfo ? userStore.userInfo.id : 0,
            productId: product.id,
            quantity: quantity,
            selected: 1, // 默认选中
            // 以下是前端展示需要的额外字段，不会发送到后端
            name: product.name,
            price: product.price,
            mainImageUrl: product.mainImageUrl,
            status: product.status,
            totalStock: product.totalStock,
            spec: product.spec || "",
          }

          this.cartItems = [...this.cartItems, cartItem]
        }

        // 保存到本地存储
        try {
          uni.setStorageSync("cartItems", JSON.stringify(this.cartItems))
        } catch (e) {
          console.error("保存购物车到本地存储失败:", e)
        }

        // 更新购物车数量
        this.getCartCount()

        // 这里将来可以替换为后端API调用
        const response = await http.post("/api/cart/add", {
          productId: product.id,
          quantity: quantity,
          selected: true,
        })

        uni.showToast({
          title: "已加入购物车",
          icon: "success",
        })

        return true
      } catch (error) {
        console.error("添加购物车失败:", error)
        uni.showToast({
          title: "添加购物车失败，请重试",
          icon: "none",
        })
        return false
      }
    },

    // 更新购物车商品数量
    async updateCartItemQuantity(productId, quantity) {
      try {
        const index = this.cartItems.findIndex((item) => item.productId === productId)
        if (index !== -1) {
          // 创建新的数组和对象来确保响应式更新
          const newCartItems = [...this.cartItems]
          newCartItems[index] = {
            ...newCartItems[index],
            quantity: quantity,
          }
          this.cartItems = newCartItems

          // 保存到本地存储
          try {
            uni.setStorageSync("cartItems", JSON.stringify(this.cartItems))
          } catch (e) {
            console.error("保存购物车到本地存储失败:", e)
          }

          return true
        }
        return false
      } catch (error) {
        console.error("更新购物车数量失败:", error)
        return false
      }
    },

    // 移除购物车商品
    async removeCartItem(productId) {
      try {
        // 使用filter创建新数组来确保响应式更新
        this.cartItems = this.cartItems.filter((item) => item.productId !== productId)

        // 保存到本地存储
        try {
          uni.setStorageSync("cartItems", JSON.stringify(this.cartItems))
        } catch (e) {
          console.error("保存购物车到本地存储失败:", e)
        }

        // 更新购物车数量
        this.getCartCount()

        return true
      } catch (error) {
        console.error("删除购物车商品失败:", error)
        return false
      }
    },

    // 切换商品选中状态
    async toggleItemSelected(productId, selected) {
      try {
        const index = this.cartItems.findIndex((item) => item.productId === productId)
        if (index !== -1) {
          // 创建新的数组和对象来确保响应式更新
          const newCartItems = [...this.cartItems]
          newCartItems[index] = {
            ...newCartItems[index],
            selected: selected ? 1 : 0, // 统一转换为数字类型
          }
          this.cartItems = newCartItems

          console.log("本地状态已更新:", {
            productId,
            selected: selected ? 1 : 0,
            selectedCount: this.selectedItemCount,
            totalPrice: this.selectedTotalPrice,
          })

          // 保存到本地存储
          try {
            uni.setStorageSync("cartItems", JSON.stringify(this.cartItems))
          } catch (e) {
            console.error("保存购物车到本地存储失败:", e)
          }

          return true
        }
        return false
      } catch (error) {
        console.error("切换商品选中状态失败:", error)
        return false
      }
    },

    // 切换全选状态
    async toggleAllSelected(selected) {
      try {
        // 创建新的数组来确保响应式更新
        const newCartItems = this.cartItems.map((item) => ({
          ...item,
          selected: selected ? 1 : 0, // 统一转换为数字类型
        }))
        this.cartItems = newCartItems

        console.log("全选状态已更新:", {
          selected,
          selectedCount: this.selectedItemCount,
          totalPrice: this.selectedTotalPrice,
        })

        // 保存到本地存储
        try {
          uni.setStorageSync("cartItems", JSON.stringify(this.cartItems))
        } catch (e) {
          console.error("保存购物车到本地存储失败:", e)
        }

        return true
      } catch (error) {
        console.error("切换全选状态失败:", error)
        return false
      }
    },

    // 清空购物车
    async clearCart() {
      try {
        this.cartItems = []

        // 清除本地存储
        try {
          uni.removeStorageSync("cartItems")
        } catch (e) {
          console.error("清除购物车本地存储失败:", e)
        }

        // 更新购物车数量
        this.getCartCount()

        return true
      } catch (error) {
        console.error("清空购物车失败:", error)
        return false
      }
    },

    // 删除已选中的商品
    async removeSelectedItems() {
      try {
        this.cartItems = this.cartItems.filter((item) => !item.selected) // 使用布尔转换

        try {
          uni.setStorageSync("cartItems", JSON.stringify(this.cartItems))
        } catch (e) {
          console.error("保存购物车到本地存储失败:", e)
        }

        this.getCartCount()
        return true
      } catch (error) {
        console.error("删除选中商品失败:", error)
        return false
      }
    },

    // 获取购物车商品数量
    getCartCount() {
      const count = this.cartItems.reduce((total, item) => total + item.quantity, 0)
      this.cartCount = count
      return count
    },
  },
})
